import random  # used for generating large random lists

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# Basic Functionality
def test_simple_unsorted_list():
    codeflash_output = sorter([3, 2, 1])
    codeflash_output = sorter([5, 3, 8, 4, 2])

def test_already_sorted_list():
    codeflash_output = sorter([1, 2, 3])
    codeflash_output = sorter([2, 4, 6, 8, 10])

def test_reverse_sorted_list():
    codeflash_output = sorter([3, 2, 1])
    codeflash_output = sorter([10, 8, 6, 4, 2])

# Edge Cases
def test_empty_list():
    codeflash_output = sorter([])

def test_single_element_list():
    codeflash_output = sorter([1])
    codeflash_output = sorter([42])

def test_two_elements_list():
    codeflash_output = sorter([2, 1])
    codeflash_output = sorter([1, 2])

# Lists with Duplicates
def test_all_elements_the_same():
    codeflash_output = sorter([1, 1, 1])
    codeflash_output = sorter([5, 5, 5, 5])

def test_some_duplicates():
    codeflash_output = sorter([3, 1, 2, 1, 3])
    codeflash_output = sorter([4, 4, 2, 2, 1, 1])

# Lists with Negative Numbers
def test_all_negative_numbers():
    codeflash_output = sorter([-3, -1, -2])
    codeflash_output = sorter([-5, -3, -8, -4, -2])

def test_mixed_positive_and_negative_numbers():
    codeflash_output = sorter([3, -1, 2, -3])
    codeflash_output = sorter([-5, 3, -8, 4, 2])

# Lists with Floating Point Numbers
def test_positive_floats():
    codeflash_output = sorter([3.1, 2.2, 1.3])
    codeflash_output = sorter([5.5, 3.3, 8.8, 4.4, 2.2])

def test_mixed_integers_and_floats():
    codeflash_output = sorter([3, 2.2, 1])
    codeflash_output = sorter([5, 3.3, 8, 4.4, 2])

# Large Scale Test Cases
def test_large_list_of_random_numbers():
    large_list = [random.randint(0, 1000) for _ in range(1000)]
    codeflash_output = sorter(large_list)

def test_large_list_of_sorted_numbers():
    large_list = list(range(1000))
    codeflash_output = sorter(large_list)

def test_large_list_of_reverse_sorted_numbers():
    large_list = list(range(1000, 0, -1))
    codeflash_output = sorter(large_list)

# Performance and Scalability Tests
def test_very_large_list_of_random_numbers():
    large_list = [random.randint(0, 1000) for _ in range(1000)]
    codeflash_output = sorter(large_list)

# Special Cases
def test_list_with_different_data_types():
    with pytest.raises(TypeError):
        sorter([3, 'a', 2])
    with pytest.raises(TypeError):
        sorter([1, 2, '3'])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

def test_sorted_list():
    # Basic functionality: already sorted list
    codeflash_output = sorter([1, 2, 3, 4, 5])
    codeflash_output = sorter([-5, -3, -1, 0, 2])

def test_reversed_list():
    # Basic functionality: reversed list
    codeflash_output = sorter([5, 4, 3, 2, 1])
    codeflash_output = sorter([10, 9, 8, 7, 6])

def test_unsorted_list():
    # Basic functionality: unsorted list
    codeflash_output = sorter([3, 1, 4, 1, 5, 9])
    codeflash_output = sorter([10, -1, 2, 8, 3])

def test_empty_list():
    # Edge case: empty list
    codeflash_output = sorter([])

def test_single_element_list():
    # Edge case: single element list
    codeflash_output = sorter([1])
    codeflash_output = sorter([-5])

def test_two_elements_list():
    # Edge case: two elements list
    codeflash_output = sorter([2, 1])
    codeflash_output = sorter([1, 2])

def test_list_with_duplicates():
    # Lists with duplicates: all elements same
    codeflash_output = sorter([1, 1, 1, 1])
    codeflash_output = sorter([0, 0, 0, 0, 0])
    # Lists with duplicates: some elements same
    codeflash_output = sorter([2, 3, 2, 1, 2])
    codeflash_output = sorter([5, 1, 5, 3, 5])

def test_list_with_negative_numbers():
    # Lists with negative numbers: all negative
    codeflash_output = sorter([-1, -2, -3, -4])
    codeflash_output = sorter([-10, -5, -7, -3])
    # Lists with negative numbers: mixed positive and negative
    codeflash_output = sorter([3, -1, 2, -2, 1])
    codeflash_output = sorter([-5, 3, 0, -2, 4])

def test_list_with_floats():
    # Lists with floating point numbers: all floats
    codeflash_output = sorter([1.1, 2.2, 3.3, 4.4])
    codeflash_output = sorter([3.14, 2.71, 1.41, 1.73])
    # Lists with floating point numbers: mixed integers and floats
    codeflash_output = sorter([1, 2.2, 3, 4.4])
    codeflash_output = sorter([5.5, 3, 2.2, 1])

def test_large_list_of_integers():
    # Large scale test cases: large list of integers
    large_list = list(range(1000, 0, -1))
    codeflash_output = sorter(large_list)
    large_list = list(range(10000, 9000, -1))
    codeflash_output = sorter(large_list)

def test_large_list_of_floats():
    # Large scale test cases: large list of floats
    large_list = [float(i) for i in range(1000, 0, -1)]
    codeflash_output = sorter(large_list)
    large_list = [float(i) for i in range(10000, 9000, -1)]
    codeflash_output = sorter(large_list)

def test_very_large_list():
    # Performance and scalability: very large list
    very_large_list = list(range(100000, 99000, -1))
    codeflash_output = sorter(very_large_list)
    very_very_large_list = list(range(1000))
    codeflash_output = sorter(very_very_large_list)

def test_list_with_extreme_values():
    # Special cases: list with extreme values
    codeflash_output = sorter([1, 2, 3, 999999999, -999999999])
    codeflash_output = sorter([2147483647, -2147483648, 0])

def test_list_with_zero():
    # Special cases: list with zero
    codeflash_output = sorter([0, 1, 2, 3])
    codeflash_output = sorter([0, -1, -2, -3])

def test_list_with_strings():
    # Non-numeric lists: strings
    codeflash_output = sorter(["apple", "banana", "cherry"])
    codeflash_output = sorter(["zebra", "elephant", "dog"])

def test_list_with_special_characters():
    # Lists with special characters
    codeflash_output = sorter(["@", "#", "$", "%"])
    codeflash_output = sorter(["!", "?", ".", ","])

def test_mixed_data_types():
    # Non-numeric lists: mixed data types (should raise an error)
    with pytest.raises(TypeError):
        sorter([1, "apple", 2.2])
    with pytest.raises(TypeError):
        sorter([None, 1, "banana"])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.